/*
 * Covian, Fernanda V.
 * Sayes, Andrès
 */
package proycompalex1;
import java.io.*;
/**
 * La clase lectorBuffer crea una conexión a un archivo fuente. Utiliza la clase
 * bufferedReader la cual realiza lecturas al archivo fuente eficientemente.
 */
public class lectorBuffer {

  private int posicion; //posicion dentro de la linea
  private int numLinea=0; // numero de linea del archivo
  private String linea; // linea obtenida a partir del archivo ingresado
  private String caracterActual; // caracter obtenido de acuerdo a la posicion
  private int longitud; // longitud de la linea que esta siendo considerada
  private BufferedReader br; // buffer en el que se encuentra el archivo de entrada
  private boolean errorLectura=false;
  private int cant_saltos=0;
/**
 * Este método informa cuando es invocado si hubo algun error al intentar leer
 * el archivo fuente que fue pasado por parámetro al constructor de la clase
 * @return boolean 
 */
    public boolean isErrorLectura() {
        return errorLectura;
    }
/**
 * Retorna la cantidad de saltos de linea que ocurrieron en la busqueda de un caracter.
 * @return un entero que representa la cantidad de saltos de linea que ocurrieron mientras se buscaba un caracter
 */
    public int getCant_saltos() {
        int i=cant_saltos;
        cant_saltos=0;
        return i;
    }

 /**
  * Retorna en número de linea actual consumida del archivo fuente.
  * @return retorna un valor entero representando el número de linea actual de lectura
  */
    public int getNum_linea() {
        return numLinea;
    }//get num
/**
 * Este método es invocado luego de descubrir que se ha llegado a un comentario de linea.
 * Obtiene una nueva linea descartando el resto de la linea actual.
 */
    public void consumirLinea()
    {
        this.obtenerLinea();
    }

/**
* setea el numero de linea
*/
    private void setNum_linea(int num_linea) {
        this.numLinea = num_linea;
    }//set num


/**
 *Obtenerlinea() es invocado luego de que la linea actual se haya consumido y no queden caracteres para leer.
 * Realiza control de el número de linea e invoca en cada ciclo de busqueda de linea al metodo {@link eliminartabs()}
 * el cual elimina todos los tabs de la linea leida. No retorna valores, los almacena en un atributo de la clase.
 */
    private void obtenerLinea(){
     try
     {
         String auxiliar="";
         Boolean encontre=false;
         boolean tiene=true;
         while(!encontre && tiene)
         {
            if(br.ready())
            {
                this.cant_saltos++;
                linea = br.readLine();
                auxiliar=linea;
                linea=eliminarTabs(auxiliar);
                if (linea != null && !linea.equals(""))
                {
                   longitud = linea.length();
                    encontre=true;
                }//if linea != null
                numLinea ++;
                posicion = 0;
            }
            else
            {
                tiene=false;
                longitud=0;
                posicion=0;
                linea=null;
            }
         
         }
     }//try
     catch (Exception e){//Catch exception if any
         System.err.println("Error: " + e.getMessage());
    }
   }//obtener linea

 private String eliminarTabs(String linea)
 {
    int i;
    int pos=0;
    int longitud=0;
    String caracter="";
    longitud=linea.length();
    String aux="";
    for(i=0;i<longitud;i++)
    {
        caracter=linea.substring(i,i+1);
        if(!(caracter.equals("\t")))
        {
            aux=aux.concat(caracter);
        }
        else
        {
            aux=aux.concat(" ");
        }
    }
    return aux;
 }
/**
 * El método leerCaracter() verifica si la linea actual tiene aún caracteres,y devuelve el siguiente caracter de
 * esta linea. Caso contrario, invoca un método para obtener una nueva linea
 * @return String. Retorna el caracter actual en un String.
 */
   public String leerCaracter()
   {
       this.cant_saltos=0;
       if (posicion >= longitud)
       {
             obtenerLinea();
           if(linea==null)/*llegue a fin de archivo*/
           {
                caracterActual=null;
           }
           else
           {
               caracterActual = linea.substring(posicion, posicion+1);
               posicion ++;
           }
       }
       else
       {
           caracterActual = linea.substring(posicion, posicion+1);
           posicion ++;
       }
       return caracterActual;
   }
/**
 * EL constructor de la clase recibe como parámetro un nombre de archivo y crea
 * un {@link BufferedReader}. Esta clase es la encargada de realizar una eficiente
 * lectura del archivo.
 * @param nombre del archivo fuente a analizar caracter a caracter
 */
   
   public lectorBuffer(String nombreArchivo)
    {
        numLinea = 0;
        try{
            File f = new File( nombreArchivo );
            br= new BufferedReader( new FileReader( f ) );
        }//try
        catch(FileNotFoundException e){
            System.err.print("error:" + e.getMessage());
       }
        catch (Exception e){//Catch exception if any
            errorLectura=true;
            System.err.println("Error: " + e.getMessage());
        }//catch
   }//lectorbuffer

}//class



